Web生态

常用软件

VirtualBox

• VirtualBox官网

• 类似VMWare的虚拟机

1. 官网历史版本

Vagrant

• VirtualBox的Linux系统各发行版镜像仓库，使用vagrant连接VirtualBox能快速拉取centos镜像通过一行命令快速创建centos虚拟机

• 详细使用见Linux指南

1. Vagrant 官方镜像仓库

2. Vagrant下载地址

Kibana

• Kibana的Dev Tools可用于使用Elasticsearch的WEB API，管理和操作ES中的数据

1. Dev Tools界面使用快捷键Ctrl+Home或者Ctrl+End可以快速跳转至控制台的首行或者最后一行

2. Dev Tools界面的格式化快捷键为Ctrl+I

JMeter

• Jmeter中选择Options--Choose Language中可以选择简体中文

1. JMeter设置

   【线程组设置】

   • Thread Group表示发送请求的最小单位是以线程作为单位的

   • Name是线程组的名称，Comments是该线程组的摘要说明，这两个都可以不填

   • Number of Threads是并发请求的用户数，意思是给并发请求启动多少个线程来模拟用户数量

   • Ramp-up period指的是这些线程在多长时间内将这些线程启动起来，可以看做多长时间内把所有请求发送出去，注意这里只是发送请求的时间，总的时间包含等待响应的时间，不同的服务器性能和响应内容可能导致总时间远远超出发送请求的时间

     • ❓：注意不是单个循环发送的时间，因为设置50个循环请求少的时候也是瞬间发完，这里具体的意思还需要明确，倾向于多长时间将这些线程启动起来，因为请求少，每个线程50次请求可以瞬间发完

   • Loop Count该线程组发送请求循环的次数【每个线程发送多少个请求】，infinite表示无限次发送请求

   

   【请求设置】

   • 点击绿色按钮是启动该线程组，弹框是提示是否保存当前设置的请求计划，点击保存会将请求设置保存在本地的jmeter的bin目录下的Summary Report.jmx文件中【就是持久化操作】，齿轮加两个扫把图标是清空全部统计数据【不清空每次测试数据会累计】

   • 取样器是选择要发送请求的样式

   • 需要在Web Server菜单指定请求的协议，目标服务器的IP地址或者被DNS解析的域名，目标服务器端口号

   • 在Http Request中指定请求的方式和请求路径

   

2. 使用jmeter分析测试结果

   【jmeter的查看测试结果集菜单】

   • listener【监听器】下有很多展示测试数据的测试结果集选项，比较常用的有以下三种，要像图中这样选中对应的选项卡，在选项卡菜单中运行线程组

   • View Result Tree：查看结果树，能够看到每次请求的响应状态和对应的响应结果

   • Summary Report：汇总报告，显示请求总数，平均、最小、最大响应时间，响应时间的方差和标准差【反应每个样本响应时间和平均值的偏差程度】，异常比例，吞吐量【该指标非常重要，通过该指标来衡量接口每秒的并发能力】，每秒接收和发送的网络数据【网络数据太慢会影响对服务器性能的判断，因为发送请求太慢】

   • View Result in Table：

   • Aggregate Report：聚合报告，显示样本总量、平均响应时间、响应时间中位数、90%、95%、99%请求完成的时间【单位是毫秒】，请求最小最大响应时间、异常比例、吞吐量、接收和发送网络数据的速率

   • Aggregation Graph：能够将统计数据以图表的形式进行展示，在列设置中设置柱状图展示的数据类型、

   

   【View Result Tree测试效果】

   • 直接选中对应的结果集选项，并按此前操作点击绿色按钮

   • 在此前的限流设置下，一秒内的十次并发请求，只有第一个成功了

   • 该结果集选项卡下能看到每个请求的请求协议信息、请求的URL和响应数据

   

   【Summary Report测试效果】

   Label字段指是发送的是哪一类请求，Http Request表示发送的是http请求，Total表示所有请求的统计信息

   Sample表示发送请求的样本个数，我发了3次十个请求，这里就显示的30个

   Average、Min、Max、Std.DEV都是响应时间，意思是响应时间的平均值，最小值、最大值和中位值

   Error是请求发送发生错误的请求比例有多少

   Throughput是指吞吐量，就是指QPS，卧槽我这里怎么是9.6个每分钟，老师的演示是11个每秒，说样本太少，展示数据的结果不准确

   Received KB/sec是指每秒接收数据的吞吐量，即网络消耗的吞吐

   Send KB/sec是指每秒发送数据的吞吐量

   Avg.Bytes是平均每秒数据吞吐量的大小

   需要关注的主要就是QPS和发送接收数据的吞吐量，如果QPS怎么也上不去，就像下图演示的情况，此时一定要关注传输数据的吞吐量，因为数据传输的速率是由网卡决定的，比如百兆网卡下载速度应该是100除以8，即12M左右，到达数据传输上限或者延迟很高QPS也是上不去的，不知道是不是我这里的网络太差的原因，但是我这儿用的是同一台主机，难道也是用网卡进行通信的吗

   注意上面的工具栏两个小扫把【悬停显示clear】可以清除页面的数据【一个是清除当前，一个是清除所有】，每次发送请求都最好点一下清除数据，方便统计

   

   【View Result in Table测试效果】

   能够看到每个请求的开始时间【毫秒级别】，请求线程、响应时间、响应状态、请求和响应数据量

   

3. 对Nginx服务器无限次请求，观察jmeter统计效果

   我这里发了十二万个请求，在nginx服务器的设定限流规则下，只有几个成功了【因为试验了几秒钟】，此时我的QPS上来了，能达到42.4每秒，卧槽老师的都快10000每秒了

   连续发起请求，整个过程40多万个请求，可以动态的显示QPS效果。我这里QPS稳定达到了14000左右每秒【最高一万七，一万七不是真实数据，我第二次请求一直单增，但是最终还是稳定1万四】，老师的还是10000左右

   虚拟机的配置相比于实际生产机极低，也能到一万多的QPS，QPS高的原因是nginx性能高此外还有请求几乎都报错，即有很多无效的QPS

   顶上error和success分别勾选能单独统计成功请求和失败请求的QPS，在ngixn设置的限流策略下随时间推移勾选成功会将QPS稳定在设置值1r/s

   而且在View Result in Table中能看到成功请求的时间间隔严格的遵循1s，完全精确到jmeter的时间刻度1ms

   

JMeter常见问题

1. JMeter报错Address Already in use

   • 问题描述：Jmeter访问测试本机127.0.0.1的端口服务，在无限请求的情况下请求产生大量异常，异常率迅速飙升超过50%，响应体报错，提示信息Address already in use

   • 原因分析：该问题实际是windows的问题，windows本身提供给TCP/IP的端口是1024-5000，且需要四分钟才会循环回收这些端口，短时间内跑大量的请求会将端口占满

   • 解决方法一：修改windows的注册文件，windows官方文档中指出当尝试大于5000的TCP端口连接时会收到大量错误，可以通过以下方案来解决

     • 1️⃣：在win+r打开窗口中使用命令regedit打开注册表

     • 2️⃣：选择计算机\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters，

     • 3️⃣：右击parameters，新建--DWORD32位，修改对应名字为MaxUserPort，点击该MaxUserPort，在弹出窗口将数值改为65534，基数为十进制【这是设置最大可用端口数量】

     • 4️⃣：右击parameters，新建--DWORD32位，修改对应名字为TCPTimedWaitDelay，点击该TCPTimedWaitDelay，在弹出窗口将数值改为30，基数为十进制【这是】设置windows回收关闭端口的等待时间为30s

     • 5️⃣：退出注册表编辑器，重启计算机配置才能生效

Jconsole

• 该工具用于远程或者本地监控Java进程的线程数目、线程运行状态、内存占用等信息

• Jconsole远程连接Java进程需要被连接Java进程在虚拟机做一些额外配置才能允许远程连接，一般项目上线测试使用Jvisualvm也需要这些配置，弹幕说叫jmx配置

1. jconsole远程连接Java进程配置

   • 被远程连接Java程序使用以下命令启动

     • ip地址：这个是当前虚拟机的IP地址，不是jconsole所在主机的IP地址

     • 连接端口：是Jconsole与远程主机的通讯端口，可以随意指定

     • 是否需要安全连接：一般自己用也不需要安全连接选择false，如果需要选择true

     • 是否需要认证：一般自己使用不需要安全认证可以选择false，如果需要选择true

     xxxxxxxxxx
     java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote -
     Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 -
     Dcom.sun.management.jmxremote.authenticate=是否认证 java类名
     

   • 通过该启动参数启动的Java进程并提供了远程监控服务，jconsole可以通过该ip和指定的监听端口连接到远程的Java进程上来进行调试，没有设置认证jconsole直接通过ip地址和端口直连就行，不需要输入用户名和口令；需要服务器开放对应端口通讯

2. 监控堆内存变化、CPU、线程指标的jconsole和jvisualvm工具

   • 这两个工具都是Java提供的，jvisualvm是jdk6以后提供的工具，是jconsole的升级版工具，一般推荐使用jvisualvm，相比于jconsole功能更强大，还可以将运行期间出现的问题以快照的形式下载下来慢慢分析来优化应用

   • jconsole的使用

     • 安装了java环境直接在CMD窗口敲命令jconsole启动jconsole控制台

     • 上来就提示需要新建连接，指要连接的具体应用，可以连接本地的，也可以连接远程的，本地进程会列举所有运行java程序的进程名称和对应的进程号，选择对应的应用进行监控

     • 监控面板

       • 概览面板

         • 监控的数据包括堆内存使用量，线程数【压力测试线程数会一直向上涨】，已加载的类数量，CPU占用率

         

       • 内存面板

         • 绿条第一个是老年代内存，第二个是伊甸园区内存，第三个是幸存者区内存，

         

       • 线程面板

         • 显示当前的每个线程和对应的堆栈跟踪信息

         

       • 类面板

         • 显示当前加载的类信息

         

    

Jvisualvm

• jvisualvm的使用

  • 安装了java环境直接在CMD窗口使用命令jvisualvm启动，弹幕说IDEA可以安装VisualVM Launcher插件，启动后选择连接目标进程，注意Java8以后不再自带jvisualvm

  • 概述面板显示了JVM参数和系统变量属性

    

  • 监视面板显示CPU信息、堆内存信息、线程数，已装载类

    • 压测期间需要观察已经使用的堆空间和已经使用的堆空间大小，线程情况和CPU情况，来观察当前应用到底是局限在CPU的计算上，还是内存经常容易满，还是线程数不够导致运行太慢等等，像下图CPU的使用了一直维持个位数的使用率，说明CPU太闲了

    

  • 线程面板显示线程的具体信息，还展示当前线程是在运行、休眠【休眠状态是调用了sleep方法的线程】、等待【等待是调用了wait方法的线程】、驻留【线程池中等待接收新任务的空闲线程】以及监视【监视的意思是两个线程发生了锁的竞争，当前线程正在进行等待锁】

    

  • 项目中还需要监控内存的垃圾回收等信息，jvisualvm默认是不带该功能的，需要安装插件，点击工具--插件，点击可用插件--检查最新版本来测试是否报错无法连接到VisualVM插件中心，如果报错，原因是需要指定插件中心的版本【修改插件中心的地址】，按照以下方式解决

    • 打开插件中心的网址https://visualvm.github.io/pluginscenters.html

    • 使用命令java -version查看本机的jdk版本java version "1.8.0_101"，重点关注小版本号101

    • 在插件中心的网址中找到小版本所在对应的版本号区间，拷贝对应版本区间的插件更新地址【点进该地址，复制页面最顶上的地址】

      

    • 在jvisualvm中点击设置--编辑Java VisualVM插件中心，将地址粘贴到弹出框的URL栏中，点击确定后会自动进行更新

    • 此时就可以直接使用可用插件菜单的插件了，安装不来用个梯子，因为github有可能连不上

  • 在可用插件中选择插件VisualVM GC，通过该插件可以观察到垃圾回收的过程，点击安装，安装完点击文件--退出，重启jvisualvm，面板会多出一个Visual GC面板，其中Old表示老年代，右边的表示新生代【最上面是伊甸园区、下面是两个幸存者区】

    • GC Time 4875 collections表示总共GC的次数为4875次，后面跟的是GC花费的总时间10.714s

    • Eden Space中是4872次GC，耗时10.495s，单次约2.15毫秒，下面的图标显示的是内存用量的实时曲线，正常健康的曲线是如下图所示的类直角三角形曲线，意味着伊甸园区的内存满了以后触发一次GC然后内存用量清零

      

    • Old Gen是老年代，是3次GC，耗时218.686毫秒，单次约72.9毫秒，性能远远低于YGC，因此线上一定要避免频繁地进行FGC，老年代内存缓慢增长，老年代满了以后执行一次FGC

    • Metaspace是元空间，是直接操作物理空间的，前面的数字是最大空间，后面的数字是当前用量，元空间的内存用量不需要关心

    

PostMan

1. 请求路径带参数

   

Java生态

SpringBoot生态

MyBatisPlus

整合MyBatisPlus

1. 引入依赖

   xxxxxxxxxx
   <!--mybatisPlus-->
   <dependency>
       <groupId>com.baomidou</groupId>
       <artifactId>mybatis-plus-boot-starter</artifactId>
       <version>3.2.0</version>
   </dependency>
   

2. 引入mysql数据库驱动依赖

   最好是对应mysql版本的mysql驱动，但是从中央仓库发现没有对应5.7.27的mysql驱动，官网给出的解释是mysql驱动5.1和8.0版本可以适配mysql5.6、5.7和8.0的所有版本，5.1兼容jre1.5、1.6、1.7、1.8，8.0只兼容jre1.8；官方推荐使用8.0版本的mysql驱动

   xxxxxxxxxx
   <!--mysql驱动-->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.17</version>
   </dependency>
   

3. 在application.yml配置数据源信息

   xxxxxxxxxx
   Spring:
     datasource:
       username: root
       password: Haworthia0715
       url: jdbc:mysql://192.168.56.10:3306?mall_pms
       driver-class-name: com.mysql.jdbc.Driver
   

4. 使用MyBatisPlus需要以下配置

   • 启动类上添加注解@MapperScan("com/earl/mall/product/dao")来告诉MybatisPlus该应用的相关Mapper接口位置

     实际该注解写在配置类上即可，接口写成Dao或者Mapper无所谓

     xxxxxxxxxx
     @MapperScan("com/earl/mall/product/dao")
     @SpringBootApplication
     public class MallProductApplication {
         public static void main(String[] args) {
             SpringApplication.run(MallProductApplication.class, args);
         }
     }
     

   • 在配置文件application.yml配置mybatis-plus.mapper-locations属性来告诉MybatisPlus该应用的相关SQL映射文件的位置

     默认配置就是classpath*:/mapper/**/*.xml，classpath*的意思是不仅扫描当前类路径，连引入依赖的类路径下也一起扫描；如果只是classpath表示只扫描当前类路径下，不扫描引入依赖的类路径

     xxxxxxxxxx
     mybatis-plus:
       mapper-locations: classpath*:/mapper/**/*.xml
     

配置主键自增

在实体类的主键上有注解@TableId，如下源码所示，该注解的自增属性默认是没有开启的，属性值为none

如果只是在实体类的主键上设置主键类型只会对当前实体类对应的数据库表生效，如果不想每个表都设置一次，可以在配置文件通过属性值mybatis-plus.global-config.db-config.id-type=auto来进行设置

​x
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface TableId {
    String value() default "";

    //默认没有开启主键自增功能
    IdType type() default IdType.NONE;
}

• 实体类的@TableId注解

  xxxxxxxxxx
  @Data
  @TableName("pms_attr_attrgroup_relation")
  public class AttrAttrgroupRelationEntity implements Serializable {
      private static final long serialVersionUID = 1L;
  
      /**
       * id
       */
      @TableId
      private Long id;
      /**
       * 属性id
       */
      private Long attrId;
      /**
       * 属性分组id
       */
      private Long attrGroupId;
      /**
       * 属性组内排序
       */
      private Integer attrSort;
  
  }
  

• 相关的IdType属性值

  • 0或者AUTO是自增主键

  • 注意除了主键自增其他的自增是MP自己的填充行为，不需要开启数据库表的主键自增功能，设置了0或者AUTO才需要开启数据库表的主键自增

  xxxxxxxxxx
  @Getter
  public enum IdType {
      /**
       * 数据库ID自增
       */
      AUTO(0),
      /**
       * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
       */
      NONE(1),
      /**
       * 用户输入ID
       * <p>该类型可以通过自己注册自动填充插件进行填充</p>
       */
      INPUT(2),
  
      /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
      /**
       * 分配ID (主键类型为number或string）,
       * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)
       *
       * @since 3.3.0
       */
      ASSIGN_ID(3),
      /**
       * 分配UUID (主键类型为 string)
       * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))
       */
      ASSIGN_UUID(4),
      /**
       * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
       */
      @Deprecated
      ID_WORKER(3),
      /**
       * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
       */
      @Deprecated
      ID_WORKER_STR(3),
      /**
       * @deprecated 3.3.0 please use {@link #ASSIGN_UUID}
       */
      @Deprecated
      UUID(4);
  
      private final int key;
  
      IdType(int key) {
          this.key = key;
      }
  }
  

• 配置该应用中所有的实体类主键自增

  xxxxxxxxxx
  mybatis-plus:
    global-config:
      db-config:
        id-type: auto
  

排除数据源自动配置

如果基础环境引入了数据库配置需要在微服务中配置数据源，但是有些微服务如网关不需要配置数据库，此时方法一是在子pom文件中排除引入的数据库依赖，方法二是在启动类上的@SpringBootApplication注解的exclude属性配置排除DatasourceAutoConfiguration.class

1. 方法1实现

   在子pom文件中排除引入的数据库依赖

   xxxxxxxxxx
   <dependency>
       <groupId>com.earl.mall</groupId>
       <artifactId>mall-common</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <exclusions>
           <exclusion>
               <groupId>com.baomidou</groupId>
               <artifactId>mybatis-plus-boot-starter</artifactId>
           </exclusion>
       </exclusions>
   </dependency>
   

2. 方法2实现

   在启动类上的@SpringBootApplication注解的exclude属性配置排除DatasourceAutoConfiguration.class

   xxxxxxxxxx
   @EnableDiscoveryClient
   @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
   public class MallGatewayApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(MallGatewayApplication.class, args);
       }
   
   }
   

    

配置逻辑删除

mybatisplus的逻辑删除是更新操作，根据id和对应的逻辑删除字段将逻辑存在的指定id的记录的逻辑删除字段改成逻辑删除

配置了逻辑删除查询操作也会自动变成查询满足条件且逻辑删除字段为逻辑未删除的记录

• 在对应模块的application.yml文件中配置逻辑删除字段值

  和默认配置相同可省略

  xxxxxxxxxx
  #mybatisplus逻辑删除配置，这是统一的全局配置，该配置就默认配置，如果配置和默认配置相同可以不写
  #从mybatisPlus3.3.0以后要配置logic-delete-field属性了，这里是3.2.0不需要配置
  #logic-delete-field: flag # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
  logic-delete-value: 1 # 逻辑已删除值(默认为 1)
  logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
  

• 配置逻辑删除组件ISqlInjector并注入IOC容器

  从MybatisPlus3.1.1开始不再需要配置该ISqlInjector组件，即高版本可省略

  xxxxxxxxxx
  @Configuration
  public class MyBatisPlusConfiguration{
      @Bean
      public ISqlInjector sqlInjector(){
          return new LogicSqlInjector();
      }
  }
  

• 在实体类的逻辑删除标识字段上添加@Tablelogic注解

  @Tablelogic注解内部有两个属性value和delval，分别表示代表逻辑未删除的字面值和逻辑删除的字面值，该属性值的默认值都为空字符串，为空字符串会自动获取全局配置，全局配置没有使用默认配置，如果不为空字符串就会优先使用该注解的配置来确定哪些值表示逻辑删除和逻辑未删除

  【@Tablelogic注解】

  xxxxxxxxxx
  @Documented
  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.FIELD)
  public @interface TableLogic {
  
      /**
       * 默认逻辑未删除值（该值可无、会自动获取全局配置）
       */
      String value() default "";
  
      /**
       * 默认逻辑删除值（该值可无、会自动获取全局配置）
       */
      String delval() default "";
  }
  

  【配置实例】

  xxxxxxxxxx
  @TableLogic(value = "1",delval = "0")
  private Integer showStatus;
  

  【执行的SQL语句】

  xxxxxxxxxx
  ==> Preparing: UPDATE pms_category SET show_status=0 WHERE cat_id IN ( ? ) AND show_status=1 
  ==> Parameters: 1432(Long)
  <== Updates: 1
  

打印SQL语句

SpringBoot调整日志级别配置打印MyBatisPlus的SQL语句

• 在应用的application.yml中配置MyBatisPlus日志级别

  这样就能打印dao包下的MyBatisPlus的SQL执行语句

  xxxxxxxxxx
  #将SpringBoot应用的com.earl.mall包下所有类的日志级别调整成DEBUG级别
  logging:
    level:
      com.earl.mall: debug
  

   

renren分页查询处理

1. 配置mp的分页插件

   xxxxxxxxxx
   @Configuration
   //@EnableTransactionManagement开启事务
   @EnableTransactionManagement
   @MapperScan("com.earl.mall.product.dao")//指定Mapper接口的位置
   public class MPPagePluginConfig {
   
       @Bean//引入分页插件
       public PaginationInterceptor paginationInterceptor(){
           PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
           //设置请求页码大于最后一页的操作，true表示调回到首页，false表示继续请求，默认为false
           paginationInterceptor.setOverflow(true);
           //设置最大单页限制数量，默认为500条，设置为-1表示不受限制
           paginationInterceptor.setLimit(1000);
           return paginationInterceptor;
       }
   }
   

2. 分页相关工具类

   • 分页参数处理

     xxxxxxxxxx
     /**
      * Copyright (c) 2016-2019 人人开源 All rights reserved.
      *
      * https://www.renren.io
      *
      * 版权所有，侵权必究！
      */
     
     package com.earl.common.utils;
     
     import com.baomidou.mybatisplus.core.metadata.IPage;
     import com.baomidou.mybatisplus.core.metadata.OrderItem;
     import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
     import com.earl.common.xss.SQLFilter;
     import org.apache.commons.lang.StringUtils;
     import java.util.Map;
     
     /**
      * 查询参数
      *
      * @author Mark sunlightcs@gmail.com
      */
     public class Query<T> {
     
         public IPage<T> getPage(Map<String, Object> params) {
             return this.getPage(params, null, false);
         }
     
         public IPage<T> getPage(Map<String, Object> params, String defaultOrderField, boolean isAsc) {
             //分页参数
             long curPage = 1;
             long limit = 10;
     
             if(params.get(Constant.PAGE) != null){
                 curPage = Long.parseLong((String)params.get(Constant.PAGE));
             }
             if(params.get(Constant.LIMIT) != null){
                 limit = Long.parseLong((String)params.get(Constant.LIMIT));
             }
     
             //分页对象
             Page<T> page = new Page<>(curPage, limit);
     
             //分页参数
             params.put(Constant.PAGE, page);
     
             //排序字段
             //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
             String orderField = SQLFilter.sqlInject((String)params.get(Constant.ORDER_FIELD));
             String order = (String)params.get(Constant.ORDER);
     
     
             //前端字段排序
             if(StringUtils.isNotEmpty(orderField) && StringUtils.isNotEmpty(order)){
                 if(Constant.ASC.equalsIgnoreCase(order)) {
                     return  page.addOrder(OrderItem.asc(orderField));
                 }else {
                     return page.addOrder(OrderItem.desc(orderField));
                 }
             }
     
             //没有排序字段，则不排序
             if(StringUtils.isBlank(defaultOrderField)){
                 return page;
             }
     
             //默认排序
             if(isAsc) {
                 page.addOrder(OrderItem.asc(defaultOrderField));
             }else {
                 page.addOrder(OrderItem.desc(defaultOrderField));
             }
             return page;
         }
     }
     

   • Query中自定义工具类SQLFilter

     xxxxxxxxxx
     /**
      * Copyright (c) 2016-2019 人人开源 All rights reserved.
      *
      * https://www.renren.io
      *
      * 版权所有，侵权必究！
      */
     
     package com.earl.common.xss;
     import com.earl.common.exceptions.RRException;
     import org.apache.commons.lang.StringUtils;
     
     /**
      * SQL过滤
      *
      * @author Mark sunlightcs@gmail.com
      */
     public class SQLFilter {
     
         /**
          * SQL注入过滤
          * @param str  待验证的字符串
          */
         public static String sqlInject(String str){
             if(StringUtils.isBlank(str)){
                 return null;
             }
             //去掉'|"|;|\字符
             str = StringUtils.replace(str, "'", "");
             str = StringUtils.replace(str, "\"", "");
             str = StringUtils.replace(str, ";", "");
             str = StringUtils.replace(str, "\\", "");
     
             //转换成小写
             str = str.toLowerCase();
     
             //非法字符
             String[] keywords = {"master", "truncate", "insert", "select", "delete", "update", "declare", "alter", "drop"};
     
             //判断是否包含非法字符
             for(String keyword : keywords){
                 if(str.indexOf(keyword) != -1){
                     throw new RRException("包含非法字符");
                 }
             }
     
             return str;
         }
     }
     

   • 涉及自定义异常类

     xxxxxxxxxx
     /**
      * Copyright (c) 2016-2019 人人开源 All rights reserved.
      *
      * https://www.renren.io
      *
      * 版权所有，侵权必究！
      */
     
     package com.earl.common.exceptions;
     
     /**
      * 自定义异常
      *
      * @author Mark sunlightcs@gmail.com
      */
     public class RRException extends RuntimeException {
         private static final long serialVersionUID = 1L;
         
         private String msg;
         private int code = 500;
         
         public RRException(String msg) {
             super(msg);
             this.msg = msg;
         }
         
         public RRException(String msg, Throwable e) {
             super(msg, e);
             this.msg = msg;
         }
         
         public RRException(String msg, int code) {
             super(msg);
             this.msg = msg;
             this.code = code;
         }
         
         public RRException(String msg, int code, Throwable e) {
             super(msg, e);
             this.msg = msg;
             this.code = code;
         }
     
         public String getMsg() {
             return msg;
         }
     
         public void setMsg(String msg) {
             this.msg = msg;
         }
     
         public int getCode() {
             return code;
         }
     
         public void setCode(int code) {
             this.code = code;
         }
             
     }
     

   • 分页数据封装工具类

     xxxxxxxxxx
     /**
      * Copyright (c) 2016-2019 人人开源 All rights reserved.
      *
      * https://www.renren.io
      *
      * 版权所有，侵权必究！
      */
     
     package com.earl.common.utils;
     
     import com.baomidou.mybatisplus.core.metadata.IPage;
     
     import java.io.Serializable;
     import java.util.List;
     
     /**
      * 分页工具类
      *
      * @author Mark sunlightcs@gmail.com
      */
     public class PageUtils implements Serializable {
         private static final long serialVersionUID = 1L;
         /**
          * 总记录数
          */
         private int totalCount;
         /**
          * 每页记录数
          */
         private int pageSize;
         /**
          * 总页数
          */
         private int totalPage;
         /**
          * 当前页数
          */
         private int currPage;
         /**
          * 列表数据
          */
         private List<?> list;
         
         /**
          * 分页
          * @param list        列表数据
          * @param totalCount  总记录数
          * @param pageSize    每页记录数
          * @param currPage    当前页数
          */
         public PageUtils(List<?> list, int totalCount, int pageSize, int currPage) {
             this.list = list;
             this.totalCount = totalCount;
             this.pageSize = pageSize;
             this.currPage = currPage;
             this.totalPage = (int)Math.ceil((double)totalCount/pageSize);
         }
     
         /**
          * 分页
          */
         public PageUtils(IPage<?> page) {
             this.list = page.getRecords();
             this.totalCount = (int)page.getTotal();
             this.pageSize = (int)page.getSize();
             this.currPage = (int)page.getCurrent();
             this.totalPage = (int)page.getPages();
         }
     
         public int getTotalCount() {
             return totalCount;
         }
     
         public void setTotalCount(int totalCount) {
             this.totalCount = totalCount;
         }
     
         public int getPageSize() {
             return pageSize;
         }
     
         public void setPageSize(int pageSize) {
             this.pageSize = pageSize;
         }
     
         public int getTotalPage() {
             return totalPage;
         }
     
         public void setTotalPage(int totalPage) {
             this.totalPage = totalPage;
         }
     
         public int getCurrPage() {
             return currPage;
         }
     
         public void setCurrPage(int currPage) {
             this.currPage = currPage;
         }
     
         public List<?> getList() {
             return list;
         }
     
         public void setList(List<?> list) {
             this.list = list;
         }
         
     }
     

3. 分页查询的使用方法

   • 参数格式

     不需要的比如排序字段、排序方式、key等属性可以不写

     xxxxxxxxxx
     {
        page: 1,//当前页码
        limit: 10,//每页记录数
        sidx: 'id',//排序字段
        order: 'asc/desc',//排序方式
        key: '华为'//检索关键字
     }
     

   • 查询方式

     【控制器方法】

     xxxxxxxxxx
     /**
      * @param params
      * @param catelogId
      * @return {@link R }
      * @描述 根据商品分类id查询属性分组 ，@RequestParam注解能获取到get请求请求路径中的参数并封装对对应名字的参数中，如果是Map，
      * 会将参数封装到Map集合中
      * @author Earl
      * @version 1.0.0
      * @创建日期 2024/02/29
      * @since 1.0.0
      */
     @RequestMapping("/list/{catelogId}")
     //@RequiresPermissions("product:attrgroup:list")
     public R list(@RequestParam Map<String, Object> params,
                   @PathVariable("catelogId") Long catelogId){
         PageUtils page = attrGroupService.queryPage(params,catelogId);
         return R.ok().put("page", page);
     }
     

     【分页查询代码】

     xxxxxxxxxx
     /**
      * @param params
      * @param catelogId
      * @return {@link PageUtils }
      * @描述 分页查询请求的参数中有一个key字段，key字段就是检索关键字，分页查询参数和key都是连接在请求url后的，
      * 这个key是renren-generator封装在自动生成的前端列表组件中的搜索框的，因为这个搜索框只有一个，想要尽可能多的展示
      * 数据，需要对该key进行模糊匹配
      * 带搜索框的查询条件为select * from pms_attr_group where catelog_id=? and (attr_group_id=key or
      * attr_group_name like %key%
      * 即查询属性分组表中商品分类id为指定值且属性分组id为搜索框内容或者属性分组的名字模糊匹配搜素内容的属性分组
      * Spring中有一个工具类StringUtils.isEmpty(str)方法能判断str是否空字符串，自5.3版本起，isEmpty(Object)已建议弃用，
      * 使用hasLength(String)或hasText(String)替代。
      * QueryWrapper的and方法可以接受函数式接口Consumer，自动传参QueryWrapper，可以在函数式接口中连续添加查询条件
      * @author Earl
      * @version 1.0.0
      * @创建日期 2024/02/29
      * @since 1.0.0
      */
     @Override
     public PageUtils queryPage(Map<String, Object> params, Long catelogId) {
         QueryWrapper<AttrGroupEntity> wrapper = new QueryWrapper<AttrGroupEntity>();
         String key = (String) params.get("key");
         if (StringUtils.hasLength(key)) {
             wrapper.and(obj->{
                 obj.eq("attr_group_id",key).
                         or().like("attr_group_name",key)
                         .or().like("descript",key)
                 ;
             });
         }
         if(catelogId!=0){
             wrapper.eq("catelog_id", catelogId);
         }
         IPage<AttrGroupEntity> page = this.page(
                 new Query<AttrGroupEntity>().getPage(params),
                 wrapper
         );
         return new PageUtils(page);
     }
     

   • 响应结果格式

     xxxxxxxxxx
     {
         "msg": "success",
         "code": 0,
         "page": {
             "totalCount": 0,
             "pageSize": 10,
             "totalPage": 0,
             "currPage": 1,
             "list": [{
                 "attrGroupId": 0, //分组id
                 "attrGroupName": "string", //分组名
                 "catelogId": 0, //所属分类
                 "descript": "string", //描述
                 "icon": "string", //图标
                 "sort": 0 //排序
                 "catelogPath": [2,45,225] //分类完整路径
             }]
         }
     }
     

4. 将查询列表数据处理成自定义封装的列表数据

   • 实例

     xxxxxxxxxx
     /**
      * @param params
      * @return {@link PageUtils }
      * @描述  带条件分页查询所有属性和属性关联的属性分组和商品分类名称
      * 从page中取出数据二次封装以后传递个PageUtils的list属性
      * @author Earl
      * @version 1.0.0
      * @创建日期 2024/03/05
      * @since 1.0.0
      */
     @Override
     public PageUtils queryPage(Map<String, Object> params,Long catelogId) {
         String key = (String) params.get("key");
         QueryWrapper<AttrEntity> wrapper = new QueryWrapper<>();
         if (StringUtils.hasLength(key)){
             wrapper.and(obj->{
                 obj.eq("attr_id",key).or().like("attr_name",key);
             });
         }
         if(catelogId!=0){
             wrapper.eq("catelog_id",catelogId);
         }
         IPage<AttrEntity> page = this.page(
                 new Query<AttrEntity>().getPage(params),
                 wrapper
         );
         PageUtils pageUtils = new PageUtils(page);
         //将分页数据从page中取出来再加工
         List<AttrListVo> responseVo = page.getRecords().stream().map(attrEntity -> {
             AttrListVo attrListVo = new AttrListVo();
             BeanUtils.copyProperties(attrEntity, attrListVo);
             AttrAttrgroupRelationEntity relation = attrAttrgroupRelationService.getOne(new QueryWrapper<AttrAttrgroupRelationEntity>().eq("attr_id", attrEntity.getAttrId()));
             if (relation != null && relation.getAttrGroupId() != null) {
                 attrListVo.setGroupName(attrGroupDao.selectById(relation.getAttrGroupId()).getAttrGroupName());
             }
             if (attrEntity.getCatelogId() != null) {
                 attrListVo.setCatelogName(categoryDao.selectById(attrEntity.getCatelogId()).getName());
             }
             return attrListVo;
         }).collect(Collectors.toList());
         pageUtils.setList(responseVo);
         return pageUtils;
     }
     

      

事务

1. 在配置类上使用注解@EnableTransactionManagement开启事务

   只有在配置类上使用了该注解才能在需要控制事务的方法上使用@Transactional注解控制事务

   xxxxxxxxxx
   @Configuration
   //@EnableTransactionManagement开启事务
   @EnableTransactionManagement
   @MapperScan("com.earl.mall.product.dao")//指定Mapper接口的位置
   public class MPPagePluginConfig {
   
       @Bean//引入分页插件
       public PaginationInterceptor paginationInterceptor(){
           PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
           //设置请求页码大于最后一页的操作，true表示调回到首页，false表示继续请求，默认为false
           paginationInterceptor.setOverflow(true);
           //设置最大单页限制数量，默认为500条，设置为-1表示不受限制
           paginationInterceptor.setLimit(1000);
           return paginationInterceptor;
       }
   }
   

2. 在目标方法上使用注解@Transactional控制操作的事务

   xxxxxxxxxx
    @Override
   @Transactional
   public void updateRelatedData(BrandEntity brand) {
       this.updateById(brand);
       if(StringUtils.hasLength(brand.getName())){
           categoryBrandRelationService.updateBrandNameByBrandId(brand.getBrandId(),brand.getName());
       }
       //TODO  品牌名称更新时更新相应的冗余数据
   }
   

    

配置自动填充字段

1. 向Spring容器注入组件

   • 代码实例

     xxxxxxxxxx
     /**
      * @author Earl
      * @version 1.0.0
      * @描述  Mp的字段自动填充组件
      * @创建日期 2024/03/27
      * @since 1.0.0
      */
     @Component
     public class MyMetaObjectHandler implements MetaObjectHandler {
     
         /**
          * @param metaObject
          * @描述  设置生成记录时需要自动填充的字段
          * @author Earl
          * @version 1.0.0
          * @创建日期 2024/03/27
          * @since 1.0.0
          */
         @Override
         public void insertFill(MetaObject metaObject) {
             this.setFieldValByName("createTime", new Date(), metaObject);
             this.setFieldValByName("updateTime", new Date(), metaObject);
         }
     
         /**
          * @param metaObject
          * @描述  设置更新记录时需要自动填充的字段
          * @author Earl
          * @version 1.0.0
          * @创建日期 2024/03/27
          * @since 1.0.0
          */
         @Override
         public void updateFill(MetaObject metaObject) {
             this.setFieldValByName("updateTime", new Date(), metaObject);
         }
     }
     

2. 在实体类指定字段上设置填充策略

   • 配置实例

     xxxxxxxxxx
     @Data
     @TableName("pms_spu_info")
     public class SpuInfoEntity implements Serializable {
         private static final long serialVersionUID = 1L;
     
         /**
          * 商品id
          */
         @TableId
         private Long id;
         /**
          * 商品名称
          */
         private String spuName;
         /**
          * 商品描述
          */
         private String spuDescription;
         /**
          * 所属分类id
          */
         private Long catelogId;
         /**
          * 品牌id
          */
         private Long brandId;
         /**
          * 商品重量
          */
         private BigDecimal weight;
         /**
          * 上架状态[0 - 下架，1 - 上架]
          */
         private Integer publishStatus;
         /**
          * 记录创建时间
          */
         @TableField(fill = FieldFill.INSERT)
         private Date createTime;
         /**
          * 记录更新时间
          */
         @TableField(fill = FieldFill.INSERT_UPDATE)
         private Date updateTime;
     
     }
     

      

Junit

1. 引入Junit依赖

   非maven项目引入junit依赖需要在本地仓库找到junit.junit-4.12和org.hamcrest.hamcrest-core-1.3,同时导入才不会报错，同时需要添加测试目录才能生效

   • Junit依赖

     junit的依赖已经被spring-boot-starter-test依赖了

     xxxxxxxxxx
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
     </dependency>
     

   • 单元测试格式

     注意，没有@RunWith(SpringRunner.class)老版本的SpringBoot涉及到自动注入的对象就会报空指针异常，新版本的SpringBoot单元测试没有这个注解

     xxxxxxxxxx
     @RunWith(SpringRunner.class)//指定使用Spring的驱动来跑单元测试，这是老版本SpringBoot的写法，新版本已经不这么写了
     @SpringBootTest
     public class MallProductApplicationTests {
         @Autowired
         BrandService brandService;
     
         @Test
         public void contextLoads() {
             BrandEntity brandEntity = new BrandEntity();
             brandEntity.setName("华为");
             System.out.println(brandService.save(brandEntity));
         }
     
     }
     

   • 异常情况

     在IDEA使用默认的SpringBoot初始化工具初始化的项目可能单元测试是以下结构

     这种结构在更换SpringBoot和SpringCloud的版本后无法直接进行单元测试，需要添加注解@RunWith(SpringRunner.class)和将测试类和方法上添加public前缀

     xxxxxxxxxx
     @SpringBootTest
     class MallOrderApplicationTests {
     
         @Test
         void contextLoads() {
         }
     
     }
     

2. 普通测试

• 在测试类上添加了@RunWith(SpringRunner.class)注解和@SpringBootTest注解的测试类是启动SpringBoot项目并对项目中的组件进行测试，我们可以不添加@RunWith(SpringRunner.class)注解和@SpringBootTest注解而只使用Junit的@Test注解不用启动SpringBoot项目只做普通测试，示例代码如下

  xxxxxxxxxx
  public class MallProductApplicationTests {
  
      @Test
      public void contextLoads() {
          BrandEntity brandEntity = new BrandEntity();
          brandEntity.setName("华为");
      }
  
  }
  

   

Lombok

• 使用Lombok需要添加对应的Lombok依赖，而且IDEA需要安装Lombok插件，作用是简化JavaBean开发

1. 依赖导入

   xxxxxxxxxx
   <!--lombok-->
   <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.8</version>
   </dependency>
   

2. API详解

   • @Data：在程序编译的时候自动为标注了@Data注解的实体类的所有非final字段添加@setter、@AllArgsConstructor、@NoArgsConstructor注解、为所有字段添加@ToString、@EqualsAndHashCode注解、@Getter注解

   • @TableName("pms_attr")：标注当前实体类对应的数据库表名

   • @NoArgsConstructor：为当前实体类填充无参构造方法

   • @AllArgsConstructor：为当前实体类填充全参构造方法

   • @ToString：重写当前实体类的toString方法

   • @Getter：自动生成Getter方法

     • 注意boolean类型的字段使用Lombok时getter方法不再以get打头，而是以is打头

   • @Setter：自动生成Setter方法

   • @Slf4j：可以在标注的类下使用属性log来记录日志

     • log.info("Exchange[{}]创建成功","hello-java-exchange")

     • 还可以为当前标注类的日志专门指定统一的日志主题

3. 用法综合示例

   xxxxxxxxxx
   import lombok.AllArgsConstructor;
   import lombok.Data;
   import lombok.NoArgsConstructor;
   import lombok.ToString;
   
   @Data//为属性自动填充getter和setter方法
   @NoArgsConstructor//无参构造
   @AllArgsConstructor//全参构造
   @ToString//重写实体类的toString方法
   public class Product {
       private Long id;//商品唯一标识
       private String title;//商品名称
       private String category;//分类名称
       private Double price;//商品价格
       private String images;//图片地址
   }
   

Logback

• 引入Logback依赖可以使用slf4j来打印日志，slf4j是接口，logback是该接口的一种实现

1. 引入依赖

   xxxxxxxxxx
   <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
       <version>1.2.3</version>
   </dependency>
   

2. logback配置文件logback.xml【类路径下】

   xxxxxxxxxx
   <?xml version="1.0" encoding="UTF-8"?>
   <configuration
       xmlns="http://ch.qos.logback/xml/ns/logback"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback logback.xsd">
       <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
           <encoder>
               <pattern>%date{HH:mm:ss} [%t] %logger - %m%n</pattern>
           </encoder>
       </appender>
       <logger name="c" level="debug" additivity="false">
           <appender-ref ref="STDOUT"/>
       </logger>
       <root level="ERROR">
           <appender-ref ref="STDOUT"/>
       </root>
   </configuration>
   

3. 常用API

   • @Slf4j(topic="c.Test2")

     • 标注该注解类中产生的日志都会在线程信息后面紧跟注解中的topic属性值，一般用作日志的记录位置区分标识

   • log.debug("{}",task.get());

     • log对象的日志函数中字符串中的大括号叫占位符，占位符的数据来自于后面紧跟着的参数，可以使用多个占位符和多个参数，依次按顺序填充

HttpCore

• 内含包org.apache.httpcomponents，是Apache用java代码实现的使用java代码发送HTTP请求的一个工具类

1. 引入依赖

   xxxxxxxxxx
   <!--httpCore-->
   <dependency>
       <groupId>org.apache.httpcomponents</groupId>
       <artifactId>httpcore</artifactId>
       <version>4.4.12</version>
   </dependency>
   

2. 依赖httpcore和httpclient的服务端Http请求发起工具类

   • 除了Httpcore和HttpClient，Spring的RestTemplate也能发起Http请求

   [HttpUtils]

   xxxxxxxxxx
   package com.earl.mall.auth.utils;
   
   import org.apache.commons.lang.StringUtils;
   import org.apache.http.HttpResponse;
   import org.apache.http.NameValuePair;
   import org.apache.http.client.HttpClient;
   import org.apache.http.client.entity.UrlEncodedFormEntity;
   import org.apache.http.client.methods.HttpDelete;
   import org.apache.http.client.methods.HttpGet;
   import org.apache.http.client.methods.HttpPost;
   import org.apache.http.client.methods.HttpPut;
   import org.apache.http.conn.ClientConnectionManager;
   import org.apache.http.conn.scheme.Scheme;
   import org.apache.http.conn.scheme.SchemeRegistry;
   import org.apache.http.conn.ssl.SSLSocketFactory;
   import org.apache.http.entity.ByteArrayEntity;
   import org.apache.http.entity.StringEntity;
   import org.apache.http.impl.client.DefaultHttpClient;
   import org.apache.http.message.BasicNameValuePair;
   
   import javax.net.ssl.SSLContext;
   import javax.net.ssl.TrustManager;
   import javax.net.ssl.X509TrustManager;
   import java.io.UnsupportedEncodingException;
   import java.net.URLEncoder;
   import java.security.KeyManagementException;
   import java.security.NoSuchAlgorithmException;
   import java.security.cert.X509Certificate;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Map;
   
   public class HttpUtils {
       
       /**
        * get
        * 
        * @param host
        * @param path
        * @param method
        * @param headers
        * @param querys
        * @return
        * @throws Exception
        */
       public static HttpResponse doGet(String host, String path, String method, 
               Map<String, String> headers, 
               Map<String, String> querys)
               throws Exception {      
           HttpClient httpClient = wrapClient(host);
   
           HttpGet request = new HttpGet(buildUrl(host, path, querys));
           for (Map.Entry<String, String> e : headers.entrySet()) {
               request.addHeader(e.getKey(), e.getValue());
           }
           
           return httpClient.execute(request);
       }
       
       /**
        * post form
        * 
        * @param host
        * @param path
        * @param method
        * @param headers
        * @param querys
        * @param bodys
        * @return
        * @throws Exception
        */
       public static HttpResponse doPost(String host, String path, String method, 
               Map<String, String> headers, 
               Map<String, String> querys, 
               Map<String, String> bodys)
               throws Exception {      
           HttpClient httpClient = wrapClient(host);
   
           HttpPost request = new HttpPost(buildUrl(host, path, querys));
           for (Map.Entry<String, String> e : headers.entrySet()) {
               request.addHeader(e.getKey(), e.getValue());
           }
   
           if (bodys != null) {
               List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
   
               for (String key : bodys.keySet()) {
                   nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
               }
               UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
               formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
               request.setEntity(formEntity);
           }
   
           return httpClient.execute(request);
       }   
       
       /**
        * Post String
        * 
        * @param host
        * @param path
        * @param method
        * @param headers
        * @param querys
        * @param body
        * @return
        * @throws Exception
        */
       public static HttpResponse doPost(String host, String path, String method, 
               Map<String, String> headers, 
               Map<String, String> querys, 
               String body)
               throws Exception {      
           HttpClient httpClient = wrapClient(host);
   
           HttpPost request = new HttpPost(buildUrl(host, path, querys));
           for (Map.Entry<String, String> e : headers.entrySet()) {
               request.addHeader(e.getKey(), e.getValue());
           }
   
           if (StringUtils.isNotBlank(body)) {
               request.setEntity(new StringEntity(body, "utf-8"));
           }
   
           return httpClient.execute(request);
       }
       
       /**
        * Post stream
        * 
        * @param host
        * @param path
        * @param method
        * @param headers
        * @param querys
        * @param body
        * @return
        * @throws Exception
        */
       public static HttpResponse doPost(String host, String path, String method, 
               Map<String, String> headers, 
               Map<String, String> querys, 
               byte[] body)
               throws Exception {      
           HttpClient httpClient = wrapClient(host);
   
           HttpPost request = new HttpPost(buildUrl(host, path, querys));
           for (Map.Entry<String, String> e : headers.entrySet()) {
               request.addHeader(e.getKey(), e.getValue());
           }
   
           if (body != null) {
               request.setEntity(new ByteArrayEntity(body));
           }
   
           return httpClient.execute(request);
       }
       
       /**
        * Put String
        * @param host
        * @param path
        * @param method
        * @param headers
        * @param querys
        * @param body
        * @return
        * @throws Exception
        */
       public static HttpResponse doPut(String host, String path, String method, 
               Map<String, String> headers, 
               Map<String, String> querys, 
               String body)
               throws Exception {      
           HttpClient httpClient = wrapClient(host);
   
           HttpPut request = new HttpPut(buildUrl(host, path, querys));
           for (Map.Entry<String, String> e : headers.entrySet()) {
               request.addHeader(e.getKey(), e.getValue());
           }
   
           if (StringUtils.isNotBlank(body)) {
               request.setEntity(new StringEntity(body, "utf-8"));
           }
   
           return httpClient.execute(request);
       }
       
       /**
        * Put stream
        * @param host
        * @param path
        * @param method
        * @param headers
        * @param querys
        * @param body
        * @return
        * @throws Exception
        */
       public static HttpResponse doPut(String host, String path, String method, 
               Map<String, String> headers, 
               Map<String, String> querys, 
               byte[] body)
               throws Exception {      
           HttpClient httpClient = wrapClient(host);
   
           HttpPut request = new HttpPut(buildUrl(host, path, querys));
           for (Map.Entry<String, String> e : headers.entrySet()) {
               request.addHeader(e.getKey(), e.getValue());
           }
   
           if (body != null) {
               request.setEntity(new ByteArrayEntity(body));
           }
   
           return httpClient.execute(request);
       }
       
       /**
        * Delete
        *  
        * @param host
        * @param path
        * @param method
        * @param headers
        * @param querys
        * @return
        * @throws Exception
        */
       public static HttpResponse doDelete(String host, String path, String method, 
               Map<String, String> headers, 
               Map<String, String> querys)
               throws Exception {      
           HttpClient httpClient = wrapClient(host);
   
           HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
           for (Map.Entry<String, String> e : headers.entrySet()) {
               request.addHeader(e.getKey(), e.getValue());
           }
           
           return httpClient.execute(request);
       }
       
       private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
           StringBuilder sbUrl = new StringBuilder();
           sbUrl.append(host);
           if (!StringUtils.isBlank(path)) {
               sbUrl.append(path);
           }
           if (null != querys) {
               StringBuilder sbQuery = new StringBuilder();
               for (Map.Entry<String, String> query : querys.entrySet()) {
                   if (0 < sbQuery.length()) {
                       sbQuery.append("&");
                   }
                   if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                       sbQuery.append(query.getValue());
                   }
                   if (!StringUtils.isBlank(query.getKey())) {
                       sbQuery.append(query.getKey());
                       if (!StringUtils.isBlank(query.getValue())) {
                           sbQuery.append("=");
                           sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                       }                   
                   }
               }
               if (0 < sbQuery.length()) {
                   sbUrl.append("?").append(sbQuery);
               }
           }
           
           return sbUrl.toString();
       }
       
       private static HttpClient wrapClient(String host) {
           HttpClient httpClient = new DefaultHttpClient();
           if (host.startsWith("https://")) {
               sslClient(httpClient);
           }
           
           return httpClient;
       }
       
       private static void sslClient(HttpClient httpClient) {
           try {
               SSLContext ctx = SSLContext.getInstance("TLS");
               X509TrustManager tm = new X509TrustManager() {
                   public X509Certificate[] getAcceptedIssuers() {
                       return null;
                   }
                   public void checkClientTrusted(X509Certificate[] xcs, String str) {
                       
                   }
                   public void checkServerTrusted(X509Certificate[] xcs, String str) {
                       
                   }
               };
               ctx.init(null, new TrustManager[] { tm }, null);
               SSLSocketFactory ssf = new SSLSocketFactory(ctx);
               ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
               ClientConnectionManager ccm = httpClient.getConnectionManager();
               SchemeRegistry registry = ccm.getSchemeRegistry();
               registry.register(new Scheme("https", 443, ssf));
           } catch (KeyManagementException ex) {
               throw new RuntimeException(ex);
           } catch (NoSuchAlgorithmException ex) {
               throw new RuntimeException(ex);
           }
       }
   }
   

    

HttpClient

• 一般市面上商用的服务端发起Http请求的工具类都会依赖于httpcore和httpclient

1. 引入依赖

   xxxxxxxxxx
   <!--httpclient-->
   <dependency>
       <groupId>org.apache.httpcomponents</groupId>
       <artifactId>httpclient</artifactId>
       <version>4.5.9</version>
   </dependency>
   

    

Servlet-api

在SpringBoot中使用Servlet相关的东西【如ServletRequest】需要在项目中引入依赖servlet-api，但是tomcat自带了servlet-api依赖，将scope改为provided，表示目标环境已经存在

xxxxxxxxxx
<!--servlet-api-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
</dependency>

Commons-lang

• apache的Commons-lang工具包，关注一下commons-lang包和commons-lang3包的不同

xxxxxxxxxx
<!--commons-lang-->
<dependency>
    <groupId>commons-lang</groupId>
    <artifactId>commons-lang</artifactId>
    <version>2.6</version>
</dependency>

StringUtils

1. boolean ---> StringUtils.isNotBlank(String param)

   • 功能解析：判断字符串param是否为空串或者只是空白字符，如果入参只含有制表符、换行符、换页符和回车符，都会被识别为空白字符判false，只要有一个字符不满足上述情况就会判true

   • 使用示例：

     xxxxxxxxxx
     //判断空白字符
     System.out.println(StringUtils.isNotBlank(" "));//false
     //判断普通字符携带空白字符
     System.out.println(StringUtils.isNotBlank("1 "));//true
     //判断制表符、换行符、换页符和回车符
     System.out.println(StringUtils.isNotBlank("\t \f \r \n "));//false
     

      

gson

2. 依赖引入

   xxxxxxxxxx
   <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>
       <version>2.8.5</version>
   </dependency>
   

validation-api

validation-api是javax旗下的，引入后可以在项目中使用JSR303规范的数据校验功能以及自定义校验注解；在SpringBoot2.3.x以前是随web-starter的hibernate-validator一起引入的

1. 依赖引入

   xxxxxxxxxx
   <!--validation-api-->
   <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
       <version>2.0.1.Final</version>
   </dependency>